```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>RabbitMQ延时插件完全指南</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            line-height: 1.8;
            color: #333;
            background-color: #f9fafb;
        }
        h1, h2, h3, h4, h5, h6 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            color: #111827;
        }
        .hero-gradient {
            background: linear-gradient(135deg, #6b46c1 0%, #805ad5 50%, #9f7aea 100%);
        }
        .card-hover {
            transition: all 0.3s ease;
        }
        .card-hover:hover {
            transform: translateY(-5px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .code-block {
            background-color: #2d3748;
            border-radius: 0.5rem;
            overflow: hidden;
        }
        .drop-cap:first-letter {
            float: left;
            font-size: 4.5rem;
            line-height: 0.65;
            margin: 0.1em 0.2em 0.1em 0;
            color: #6b46c1;
            font-weight: bold;
        }
        .highlight-box {
            border-left: 4px solid #6b46c1;
            background-color: #f8f9fa;
        }
    </style>
</head>
<body class="antialiased">
    <!-- Hero Section -->
    <section class="hero-gradient text-white py-20 px-4 sm:px-6 lg:px-8">
        <div class="max-w-5xl mx-auto text-center">
            <div class="flex justify-center mb-6">
                <span class="inline-flex items-center px-3 py-1 rounded-full text-sm font-medium bg-white text-purple-800">
                    <i class="fas fa-rabbit mr-2"></i> RabbitMQ 高级特性
                </span>
            </div>
            <h1 class="text-4xl md:text-5xl font-bold mb-6 leading-tight">RabbitMQ 延时插件完全指南</h1>
            <p class="text-xl md:text-2xl opacity-90 max-w-3xl mx-auto mb-10">
                掌握延时消息处理的核心技术，构建高效可靠的异步任务系统
            </p>
            <div class="flex justify-center space-x-4">
                <a href="#installation" class="px-6 py-3 bg-white text-purple-700 font-medium rounded-lg hover:bg-gray-100 transition duration-300">
                    <i class="fas fa-download mr-2"></i> 立即安装
                </a>
                <a href="#use-cases" class="px-6 py-3 bg-transparent border-2 border-white text-white font-medium rounded-lg hover:bg-white hover:text-purple-700 transition duration-300">
                    <i class="fas fa-lightbulb mr-2"></i> 使用场景
                </a>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <div class="max-w-5xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
        <!-- Introduction -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-1 bg-purple-500 rounded-full mr-4"></div>
                <h2 class="text-3xl font-bold">RabbitMQ延时插件</h2>
            </div>
            <div class="grid md:grid-cols-2 gap-8 items-center">
                <div>
                    <p class="text-lg mb-6 drop-cap">在实际的开发中，我们经常需要在消息发送之后延迟一段时间后再进行消费，或者在某个特定的时间点触发某些任务的执行。传统的做法可能是通过编写定时任务或者手动处理，但这种方式通常不够灵活和高效。</p>
                    <p class="text-lg mb-6">而 RabbitMQ 延时插件的出现，为我们提供了一种更加简单和便捷的解决方案。通过 RabbitMQ 延时插件，我们可以轻松地设置消息的延时发送和消费时间，而无需编写复杂的定时任务或者手动处理逻辑。这不仅大大简化了开发流程，提高了开发效率，同时也增强了系统的可靠性和稳定性。</p>
                </div>
                <div class="rounded-xl overflow-hidden shadow-lg">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1714712351846-3887a6b0-6419-42f3-9d86-11a073754fc1.png" alt="RabbitMQ延时插件示意图" class="w-full h-auto">
                </div>
            </div>
        </section>

        <!-- Delayed Messages & Queues -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-1 bg-purple-500 rounded-full mr-4"></div>
                <h2 class="text-3xl font-bold">延迟消息和延迟队列</h2>
            </div>
            <div class="grid md:grid-cols-2 gap-8 mb-12">
                <div class="bg-white rounded-xl shadow-md overflow-hidden card-hover">
                    <div class="p-6">
                        <div class="flex items-center mb-4">
                            <div class="w-10 h-10 rounded-full bg-purple-100 flex items-center justify-center mr-3">
                                <i class="fas fa-clock text-purple-600"></i>
                            </div>
                            <h3 class="text-xl font-bold">什么是延迟消息</h3>
                        </div>
                        <p class="mb-4">延迟消息是指在发送消息后，消息不会立即被投递给消费者，而是延迟一段时间后再进行投递。这种延迟的目的通常是为了在一定的时间后触发某些特定的事件或者处理某些业务逻辑，例如订单超时未支付处理、任务调度执行等。</p>
                        <p>在传统的消息队列中，消息发送和消费通常是立即进行的，即消息一旦被发送就会立即被消费者接收到并进行处理。但在某些场景下，我们希望消息能够在一段时间后才被消费者接收，这就需要借助延迟消息的机制来实现。</p>
                    </div>
                </div>
                <div class="bg-white rounded-xl shadow-md overflow-hidden card-hover">
                    <div class="p-6">
                        <div class="flex items-center mb-4">
                            <div class="w-10 h-10 rounded-full bg-purple-100 flex items-center justify-center mr-3">
                                <i class="fas fa-list-alt text-purple-600"></i>
                            </div>
                            <h3 class="text-xl font-bold">什么是延迟队列</h3>
                        </div>
                        <p class="mb-4">延迟队列是一种特殊类型的消息队列，用于存储延迟消息，并在一定的延迟时间后将消息投递给消费者进行处理。与普通队列不同的是，延迟队列可以设置消息的延迟时间，使得消息在指定的时间后才会被消费者接收到。</p>
                        <p>延迟队列通常由两部分组成：生产者和消费者。生产者负责向延迟队列发送延迟消息，并设置消息的延迟时间；消费者则负责从延迟队列中获取延迟消息，并在延迟时间到达后进行处理。</p>
                    </div>
                </div>
            </div>
            <div class="rounded-xl overflow-hidden shadow-lg">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1714712460183-2ace1d06-c9f0-4625-90e4-bfbd531dab88.png" alt="延迟消息和延迟队列示意图" class="w-full h-auto">
            </div>
        </section>

        <!-- Plugin Introduction -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-1 bg-purple-500 rounded-full mr-4"></div>
                <h2 class="text-3xl font-bold">延时插件的介绍</h2>
            </div>
            <p class="text-lg mb-8">RabbitMQ 延时插件是 RabbitMQ 中的一个插件，它允许在消息传递过程中延迟消息的投递时间。简单来说，延时插件允许你发送一条消息，并指定这条消息在未来的某个特定时间才被消费者接收和处理。</p>
            
            <div class="grid md:grid-cols-3 gap-6 mb-8">
                <div class="bg-white rounded-xl shadow-md p-6 card-hover">
                    <div class="w-12 h-12 rounded-full bg-purple-100 flex items-center justify-center mb-4">
                        <i class="fas fa-tasks text-purple-600 text-xl"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3">消息调度和任务延时执行</h3>
                    <p>延时插件可以用于实现消息的调度和任务的延时执行。例如，你可以将某个需要延时执行的任务封装成一条消息，然后将这条消息发送到 RabbitMQ 中，指定它在未来的某个时间点才被消费者处理，从而实现任务的延时执行。</p>
                </div>
                <div class="bg-white rounded-xl shadow-md p-6 card-hover">
                    <div class="w-12 h-12 rounded-full bg-purple-100 flex items-center justify-center mb-4">
                        <i class="fas fa-sync-alt text-purple-600 text-xl"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3">消息重试和超时处理</h3>
                    <p>在消息处理系统中，经常会遇到需要对消息进行重试或者在超时后进行处理的情况。延时插件可以用于实现消息的重试机制和超时处理策略。例如，你可以将消息发送到延时队列中，并设置消息的过期时间，当消息过期后，可以将它发送到其他队列进行重试或者进行超时处理。</p>
                </div>
                <div class="bg-white rounded-xl shadow-md p-6 card-hover">
                    <div class="w-12 h-12 rounded-full bg-purple-100 flex items-center justify-center mb-4">
                        <i class="fas fa-shopping-cart text-purple-600 text-xl"></i>
                    </div>
                    <h3 class="text-xl font-bold mb-3">订单处理和定时任务调度</h3>
                    <p>在电商系统中，经常会遇到订单处理和定时任务调度的场景。延时插件可以用于实现订单的延时处理和定时任务的调度。例如，你可以将订单信息封装成一条消息，然后将这条消息发送到 RabbitMQ 中，指定它在订单超时未支付时才被消费者处理。</p>
                </div>
            </div>
            
            <div class="rounded-xl overflow-hidden shadow-lg">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1714712507376-cf032a65-cd9c-412e-9d23-38d3873d9357.png" alt="延时插件功能示意图" class="w-full h-auto">
            </div>
        </section>

        <!-- Installation -->
        <section id="installation" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-1 bg-purple-500 rounded-full mr-4"></div>
                <h2 class="text-3xl font-bold">延迟插件的安装</h2>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8 mb-8">
                <div>
                    <div class="flex items-start mb-6">
                        <div class="flex-shrink-0 bg-purple-100 rounded-lg p-3 mr-4">
                            <i class="fas fa-check-circle text-purple-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-bold mb-2">1. 检查 RabbitMQ 版本</h3>
                            <p>在安装延时插件之前，首先需要确认正在使用的 RabbitMQ 版本是否支持延时插件。延时插件通常需要 RabbitMQ 版本在3.6.0及以上。</p>
                        </div>
                    </div>
                    
                    <div class="flex items-start mb-6">
                        <div class="flex-shrink-0 bg-purple-100 rounded-lg p-3 mr-4">
                            <i class="fas fa-download text-purple-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-bold mb-2">2. 下载延时插件</h3>
                            <p>访问 RabbitMQ 官方网站或 GitHub 仓库，下载延时插件的压缩包文件。通常情况下，延时插件的压缩包文件名为 <code class="bg-gray-100 px-2 py-1 rounded">rabbitmq_delayed_message_exchange-X.Y.Z.ez</code>，其中 X.Y.Z 是插件的版本号。</p>
                        </div>
                    </div>
                    
                    <div class="flex items-start mb-6">
                        <div class="flex-shrink-0 bg-purple-100 rounded-lg p-3 mr-4">
                            <i class="fas fa-file-archive text-purple-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-bold mb-2">3. 解压插件文件</h3>
                            <p>将下载的延时插件压缩包文件解压到一个合适的目录中。解压后，你会得到一个名为 <code class="bg-gray-100 px-2 py-1 rounded">rabbitmq_delayed_message_exchange-X.Y.Z</code> 的文件夹，其中 X.Y.Z 是插件的版本号。</p>
                        </div>
                    </div>
                </div>
                
                <div>
                    <div class="flex items-start mb-6">
                        <div class="flex-shrink-0 bg-purple-100 rounded-lg p-3 mr-4">
                            <i class="fas fa-copy text-purple-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-bold mb-2">4. 复制插件文件到 RabbitMQ 插件目录</h3>
                            <p>将解压后得到的延时插件文件夹复制到 RabbitMQ 的插件目录中。通常情况下，RabbitMQ 的插件目录位于 RabbitMQ 安装目录下的 <code class="bg-gray-100 px-2 py-1 rounded">plugins</code> 文件夹内。</p>
                        </div>
                    </div>
                    
                    <div class="flex items-start mb-6">
                        <div class="flex-shrink-0 bg-purple-100 rounded-lg p-3 mr-4">
                            <i class="fas fa-power-off text-purple-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-bold mb-2">5. 启用插件</h3>
                            <p>使用 RabbitMQ 的命令行工具或 Web 控制台启用延时插件。在命令行中，可以使用 <code class="bg-gray-100 px-2 py-1 rounded">rabbitmq-plugins enable rabbitmq_delayed_message_exchange</code> 命令启用延时插件。</p>
                        </div>
                    </div>
                    
                    <div class="flex items-start mb-6">
                        <div class="flex-shrink-0 bg-purple-100 rounded-lg p-3 mr-4">
                            <i class="fas fa-check-double text-purple-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-bold mb-2">6. 验证插件是否启用成功</h3>
                            <p>启用延时插件后，需要验证插件是否成功加载和启用。可以使用命令行工具或 Web 控制台查看已经启用的插件列表，确保延时插件在列表中显示为已启用状态。</p>
                        </div>
                    </div>
                    
                    <div class="flex items-start">
                        <div class="flex-shrink-0 bg-purple-100 rounded-lg p-3 mr-4">
                            <i class="fas fa-redo text-purple-600 text-xl"></i>
                        </div>
                        <div>
                            <h3 class="text-xl font-bold mb-2">7. 重启 RabbitMQ 服务器</h3>
                            <p>在启用延时插件后，建议重启 RabbitMQ 服务器以确保插件能够正确加载和生效。可以使用命令行工具或 Web 控制台重启 RabbitMQ 服务器。</p>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- Configuration -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-1 bg-purple-500 rounded-full mr-4"></div>
                <h2 class="text-3xl font-bold">延时插件的配置</h2>
            </div>
            
            <div class="mb-8">
                <h3 class="text-2xl font-bold mb-4 flex items-center">
                    <span class="w-8 h-8 rounded-full bg-purple-100 flex items-center justify-center mr-3">
                        <i class="fas fa-exchange-alt text-purple-600"></i>
                    </span>
                    1. 定义延时交换机和队列
                </h3>
                <p class="mb-4">在 RabbitMQ 中，延时插件通过延时交换机和延时队列来实现延时消息的投递。首先需要定义一个延时交换机和一个延时队列。</p>
                <div class="code-block mb-6">
                    <pre class="text-gray-200 p-4 overflow-x-auto"><code>@Bean
public CustomExchange delayExchange() {
    Map&lt;String, Object&gt; args = new HashMap&lt;&gt;();
    args.put("x-delayed-type", "direct");
    return new CustomExchange("delayed-exchange", "x-delayed-message", true, false, args);
}

@Bean
public Queue delayedQueue() {
    return new Queue("delayed-queue");
}

@Bean
public Binding binding(Queue delayedQueue, CustomExchange delayExchange) {
    return BindingBuilder.bind(delayedQueue).to(delayExchange).with("").noargs();
}</code></pre>
                </div>
            </div>
            
            <div class="mb-8">
                <h3 class="text-2xl font-bold mb-4 flex items-center">
                    <span class="w-8 h-8 rounded-full bg-purple-100 flex items-center justify-center mr-3">
                        <i class="fas fa-cog text-purple-600"></i>
                    </span>
                    2. 配置消息的延时属性
                </h3>
                <p class="mb-4">在发送消息时，需要设置消息的延时属性。延时插件通常会使用消息的属性来确定消息何时被投递。常见的延时属性包括消息的 TTL（Time To Live）和延时级别等。</p>
                <div class="code-block mb-6">
                    <pre class="text-gray-200 p-4 overflow-x-auto"><code>rabbitTemplate.convertAndSend("delayed-exchange", "", message, new MessagePostProcessor() {
    @Override
    public Message postProcessMessage(Message message) throws AmqpException {
        message.getMessageProperties().setDelay(5000); // 设置消息延时时间为 5000 毫秒
        return message;
    }
});</code></pre>
                </div>
            </div>
            
            <div>
                <h3 class="text-2xl font-bold mb-4 flex items-center">
                    <span class="w-8 h-8 rounded-full bg-purple-100 flex items-center justify-center mr-3">
                        <i class="fas fa-user-cog text-purple-600"></i>
                    </span>
                    3. 处理延时消息
                </h3>
                <p class="mb-4">编写消费者程序来处理延时消息。消费者程序需要连接到 RabbitMQ 服务器，并订阅延时队列以接收延时消息。一旦延时消息到达延时队列，消费者程序就可以将其处理。</p>
                <div class="code-block">
                    <pre class="text-gray-200 p-4 overflow-x-auto"><code>@RabbitListener(queues = "delayed-queue")
public void handleMessage(String message) {
    System.out.println("Received delayed message: " + message);
}</code></pre>
                </div>
            </div>
        </section>

        <!-- Performance -->
        <section class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-1 bg-purple-500 rounded-full mr-4"></div>
                <h2 class="text-3xl font-bold">延时插件的性能和特点</h2>
            </div>
            
            <p class="text-lg mb-8">RabbitMQ 延时插件提供了一种方便的方式来处理延时消息，但在实际应用中需要权衡延时消息带来的性能影响。在设计和使用延时消息系统时，需要综合考虑消息发送延迟、存储成本、消费处理延迟等因素，以保证系统的性能和可靠性。</p>
            
            <div class="grid md:grid-cols-2 gap-8 mb-8">
                <div class="bg-white rounded-xl shadow-md p-6">
                    <h3 class="text-2xl font-bold mb-6 text-center">消息发送性能特点</h3>
                    <div class="space-y-4">
                        <div class="flex items-start">
                            <div class="flex-shrink-0 text-purple-600 mr-3 mt-1">
                                <i class="fas fa-hourglass-half"></i>
                            </div>
                            <div>
                                <h4 class="font-bold mb-1">延时消息的发送延迟</h4>
                                <p>当发送延时消息时，需要额外的处理来设置消息的延时属性。这可能会导致消息发送的延迟，特别是在消息量大、网络延迟高的情况下。因此，在高性能要求的场景中，需要考虑延时消息发送的性能影响。</p>
                            </div>
                        </div>
                        <div class="flex items-start">
                            <div class="flex-shrink-0 text-purple-600 mr-3 mt-1">
                                <i class="fas fa-database"></i>
                            </div>
                            <div>
                                <h4 class="font-bold mb-1">消息存储和处理成本</h4>
                                <p>延时消息通常需要在 RabbitMQ 中存储一段时间，直到延时时间到达后再被投递。这可能会增加 RabbitMQ 服务器的存储和处理成本，尤其是对于大量延时消息的情况。</p>
                            </div>
                        </div>
                    </div>
                </div>
                <div class="bg-white rounded-xl shadow-md p-6">
                    <h3 class="text-2xl font-bold mb-6 text-center">消息消费性能特点</h3>
                    <div class="space-y-4">
                        <div class="flex items-start">
                            <div class="flex-shrink-0 text-purple-600 mr-3 mt-1">
                                <i class="fas fa-tachometer-alt"></i>
                            </div>
                            <div>
                                <h4 class="font-bold mb-1">延时消息的处理延迟</h4>
                                <p>延时消息的消费可能会受到延时队列中消息数量的影响，特别是在高负载情况下。消费者需要等待延时时间到达后才能从延时队列中获取消息进行处理，这可能会导致消息的处理延迟。</p>
                            </div>
                        </div>
                        <div class="flex items-start">
                            <div class="flex-shrink-0 text-purple-600 mr-3 mt-1">
                                <i class="fas fa-users"></i>
                            </div>
                            <div>
                                <h4 class="font-bold mb-1">消费者竞争和负载均衡</h4>
                                <p>如果有多个消费者订阅了延时队列，它们可能会竞争消费延时消息。在高并发情况下，这可能会导致消费者之间的负载不均衡，从而影响消息的及时处理。</p>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
            
            <div class="mermaid">
                graph TD
                    A[生产者] -->|发送延时消息| B[延时交换机]
                    B -->|根据延迟时间| C[延时队列]
                    C -->|延迟时间到达| D[消费者1]
                    C -->|延迟时间到达| E[消费者2]
                    C -->|延迟时间到达| F[消费者3]
            </div>
        </section>

        <!-- Use Cases -->
        <section id="use-cases" class="mb-16">
            <div class="flex items-center mb-8">
                <div class="w-12 h-1 bg-purple-500 rounded-full mr-4"></div>
                <h2 class="text-3xl font-bold">延时插件的使用场景</h2>
            </div>
            
            <p class="text-lg mb-8">一个常见的使用场景是处理订单超时自动取消功能。假设我们有一个电子商务平台，用户下单后需要在一定时间内完成支付，否则订单将被取消。我们可以使用 RabbitMQ 延时插件来实现订单超时自动取消的功能。</p>
            
            <div class="mb-8">
                <h3 class="text-2xl font-bold mb-4">场景描述</h3>
                <p class="mb-6">假设用户下单后，订单信息将被发送到 RabbitMQ 中的一个交换机，并通过延时队列设置订单超时时间。当订单超时时间到达后，延时队列会将订单信息重新路由到一个处理订单超时的队列，然后我们的系统会从这个队列中取出订单信息，进行取消订单的处理。</p>
                
                <div class="code-block mb-8">
                    <pre class="text-gray-200 p-4 overflow-x-auto"><code>@Service
public class OrderService {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void placeOrder(Order order) {
        // 将订单信息发送到交换机
        rabbitTemplate.convertAndSend("order-exchange", "", order, new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                // 设置订单的延时属性，例如设置订单超时时间为 30 分钟
                message.getMessageProperties().setDelay(30 * 60 * 1000);
                return message;
            }
        });
    }
}

@Component
public class OrderTimeoutHandler {

    @RabbitListener(queues = "order-timeout-queue")
    public void handleTimeoutOrder(Order order) {
        // 处理订单超时逻辑，例如取消订单
        System.out.println("Order timeout, canceling order: " + order.getOrderNumber());
        // Cancel order logic...
    }
}</code></pre>
                </div>
                
                <div class="highlight-box p-6 rounded-lg">
                    <div class="flex">
                        <div class="flex-shrink-0 mr-4">
                            <i class="fas fa-info-circle text-purple-600 text-2xl"></i>
                        </div>
                        <div>
                            <h4 class="font-bold text-lg mb-2">代码说明</h4>
                            <p><code class="bg-gray-200 px-1 py-0.5 rounded">OrderService</code> 类负责发送订单信息到 RabbitMQ 交换机，并设置订单的延时属性；<code class="bg-gray-200 px-1 py-0.5 rounded">OrderTimeoutHandler</code> 类通过 <code class="bg-gray-200 px-1 py-0.5 rounded">@RabbitListener</code> 注解监听订单超时队列，一旦接收到超时订单，就会执行取消订单的逻辑。通过这种方式，我们可以很方便地实现订单超时自动取消的功能，提高了系统的稳定性和用户体验。</p>
                        </div>
                    </div>
                </div>
            </div>
            
            <div>
                <h3 class="text-2xl font-bold mb-4">其他常见应用场景</h3>
                <div class="grid md:grid-cols-3 gap-6">
                    <div class="bg-white rounded-xl shadow-md p-6 card-hover">
                        <div class="w-12 h-12 rounded-full bg-purple-100 flex items-center justify-center mb-4 mx-auto">
                            <i class="fas fa-calendar-check text-purple-600 text-xl"></i>
                        </div>
                        <h4 class="text-xl font-bold mb-3 text-center">定时任务调度</h4>
                        <p>在特定时间执行后台任务，如日报生成、数据统计等，通过延时消息实现精确的任务触发。</p>
                    </div>
                    <div class="bg-white rounded-xl shadow-md p-6 card-hover">
                        <div class="w-12 h-12 rounded-full bg-purple-100 flex items-center justify-center mb-4 mx-auto">
                            <i class="fas fa-retweet text-purple-600 text-xl"></i>
                        </div>
                        <h4 class="text-xl font-bold mb-3 text-center">消息重试机制</h4>
                        <p>当消息处理失败时，可以设置一定的延迟时间后重试，避免立即重试导致的系统过载。</p>
                    </div>
                    <div class="bg-white rounded-xl shadow-md p-6 card-hover">
                        <div class="w-12 h-12 rounded-full bg-purple-100 flex items-center justify-center mb-4 mx-auto">
                            <i class="fas fa-bell text-purple-600 text-xl"></i>
                        </div>
                        <h4 class="text-xl font-bold mb-3 text-center">通知提醒</h4>
                        <p>实现预约提醒、会议通知等功能，在特定时间向用户发送提醒消息。</p>
                    </div>
                </div>
            </div>
        </section>
    </div>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```